package com.freeter.modules.gjs.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.freeter.common.exception.RRException;
import com.freeter.modules.gjs.entity.MstrCat00;
import com.freeter.modules.gjs.mapper.MstrCat00Mapper;
import com.freeter.modules.gjs.service.MstrCat00Service;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * MstrCat00服务实现类
 * 提供分类管理相关的业务逻辑实现
 * 
 * @author freeter
 * @since 1.0.0
 */
@Service
public class MstrCat00ServiceImpl implements MstrCat00Service {
    
    private static final Logger logger = LoggerFactory.getLogger(MstrCat00ServiceImpl.class);
    
    @Autowired
    private MstrCat00Mapper mstrCat00Mapper;

    /**
     * 获取所有分类信息（未删除）
     * 
     * @return 分类列表
     */
    @Override
    public List<MstrCat00> listAll() {
        try {
            Wrapper<MstrCat00> wrapper = new EntityWrapper<>();
            wrapper.eq("is_deleted", 0); // 只查询未删除的记录
            wrapper.orderBy("id", true); // 按ID升序排列
            return mstrCat00Mapper.selectList(wrapper);
        } catch (Exception e) {
            logger.error("获取所有分类信息失败", e);
            throw new RRException("获取分类信息失败：" + e.getMessage());
        }
    }

    /**
     * 根据ID获取分类信息
     * 
     * @param id 分类ID
     * @return 分类实体
     */
    @Override
    public MstrCat00 getById(Long id) {
        if (id == null || id <= 0) {
            logger.warn("分类ID不能为空或负数: {}", id);
            return null;
        }
        
        try {
            Wrapper<MstrCat00> wrapper = new EntityWrapper<>();
            wrapper.eq("id", id).eq("is_deleted", 0);
            List<MstrCat00> categories = mstrCat00Mapper.selectList(wrapper);
            return categories.isEmpty() ? null : categories.get(0);
        } catch (Exception e) {
            logger.error("根据ID获取分类信息失败, id: {}", id, e);
            throw new RRException("获取分类信息失败：" + e.getMessage());
        }
    }

    /**
     * 创建新分类
     * 
     * @param entity 分类实体
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void create(MstrCat00 entity) {
        if (entity == null) {
            logger.warn("分类实体不能为空");
            throw new RRException("分类实体不能为空");
        }
        
        try {
            // 设置默认值
            if (entity.getIsDeleted() == null) {
                entity.setIsDeleted(0);
            }
            
            // 验证必填字段
            validateEntity(entity);
            
            // 检查是否已存在相同ID的分类
            if (entity.getId() != null) {
                MstrCat00 existingCategory = mstrCat00Mapper.selectById(entity.getId());
                if (existingCategory != null) {
                    logger.warn("分类ID已存在: {}", entity.getId());
                    throw new RRException("分类ID已存在：" + entity.getId());
                }
            }
            
            int result = mstrCat00Mapper.insert(entity);
            if (result <= 0) {
                throw new RRException("创建分类失败");
            }
            
            logger.info("成功创建分类, id: {}", entity.getId());
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("创建分类失败", e);
            throw new RRException("创建分类失败：" + e.getMessage());
        }
    }

    /**
     * 更新分类信息
     * 
     * @param entity 分类实体
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(MstrCat00 entity) {
        if (entity == null || entity.getId() == null) {
            logger.warn("分类实体或ID不能为空");
            throw new RRException("分类实体或ID不能为空");
        }
        
        try {
            // 检查分类是否存在
            MstrCat00 existingCategory = mstrCat00Mapper.selectById(entity.getId());
            if (existingCategory == null) {
                logger.warn("分类不存在, id: {}", entity.getId());
                throw new RRException("分类不存在：" + entity.getId());
            }
            
            // 验证必填字段
            validateEntity(entity);
            
            // 保持原有的删除标记
            if (entity.getIsDeleted() == null) {
                entity.setIsDeleted(existingCategory.getIsDeleted());
            }
            
            int result = mstrCat00Mapper.updateById(entity);
            if (result <= 0) {
                throw new RRException("更新分类失败");
            }
            
            logger.info("成功更新分类, id: {}", entity.getId());
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("更新分类失败, id: {}", entity.getId(), e);
            throw new RRException("更新分类失败：" + e.getMessage());
        }
    }

    /**
     * 删除分类（逻辑删除）
     * 
     * @param id 分类ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(Long id) {
        if (id == null || id <= 0) {
            logger.warn("分类ID不能为空或负数: {}", id);
            throw new RRException("分类ID不能为空或负数");
        }
        
        try {
            // 检查分类是否存在
            MstrCat00 existingCategory = mstrCat00Mapper.selectById(id);
            if (existingCategory == null) {
                logger.warn("分类不存在, id: {}", id);
                throw new RRException("分类不存在：" + id);
            }
            
            // 逻辑删除：设置删除标记
            MstrCat00 category = new MstrCat00();
            category.setId(id);
            category.setIsDeleted(1);
            
            int result = mstrCat00Mapper.updateById(category);
            if (result <= 0) {
                throw new RRException("删除分类失败");
            }
            
            logger.info("成功删除分类, id: {}", id);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("删除分类失败, id: {}", id, e);
            throw new RRException("删除分类失败：" + e.getMessage());
        }
    }

    /**
     * 验证分类实体的必填字段
     * 
     * @param entity 分类实体
     */
    private void validateEntity(MstrCat00 entity) {
        if (StringUtils.isBlank(entity.getDescEn())) {
            throw new RRException("英文描述不能为空");
        }
        
        // 可以根据业务需求添加更多验证规则
        if (entity.getIsDeleted() != null && entity.getIsDeleted() != 0 && entity.getIsDeleted() != 1) {
            throw new RRException("删除标记值无效");
        }
    }

    /**
     * 根据条件查询分类
     * 
     * @param descEn 英文描述
     * @param descCn 中文描述
     * @param isDeleted 删除标记
     * @return 分类列表
     */
    public List<MstrCat00> getCategoriesByCondition(String descEn, String descCn, Integer isDeleted) {
        try {
            Wrapper<MstrCat00> wrapper = new EntityWrapper<>();
            
            if (StringUtils.isNotBlank(descEn)) {
                wrapper.like("desc_en", descEn);
            }
            if (StringUtils.isNotBlank(descCn)) {
                wrapper.like("desc_cn", descCn);
            }
            if (isDeleted != null) {
                wrapper.eq("is_deleted", isDeleted);
            } else {
                wrapper.eq("is_deleted", 0); // 默认只查询未删除的
            }
            
            wrapper.orderBy("id", true);
            return mstrCat00Mapper.selectList(wrapper);
        } catch (Exception e) {
            logger.error("根据条件查询分类失败", e);
            throw new RRException("查询分类失败：" + e.getMessage());
        }
    }

    /**
     * 检查分类是否存在
     * 
     * @param id 分类ID
     * @return 是否存在
     */
    public boolean existsById(Long id) {
        if (id == null || id <= 0) {
            return false;
        }
        
        try {
            Wrapper<MstrCat00> wrapper = new EntityWrapper<>();
            wrapper.eq("id", id).eq("is_deleted", 0);
            return mstrCat00Mapper.selectCount(wrapper) > 0;
        } catch (Exception e) {
            logger.error("检查分类是否存在失败, id: {}", id, e);
            return false;
        }
    }
} 